home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 January / macformat-020.iso / Shareware City / Developers / OutOfPhase1.01Source / OutOfPhase Folder / Level 0 Macintosh 07Aug94 / Audit.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-01  |  10.6 KB  |  434 lines  |  [TEXT/KAHL]
  1. /* Audit.c */
  2. /*****************************************************************************/
  3. /*                                                                           */
  4. /*    System Dependency Library for Building Portable Software               */
  5. /*    Macintosh Version                                                      */
  6. /*    Written by Thomas R. Lawrence, 1993 - 1994.                            */
  7. /*                                                                           */
  8. /*    This file is Public Domain; it may be used for any purpose whatsoever  */
  9. /*    without restriction.                                                   */
  10. /*                                                                           */
  11. /*    This package is distributed in the hope that it will be useful,        */
  12. /*    but WITHOUT ANY WARRANTY; without even the implied warranty of         */
  13. /*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.                   */
  14. /*                                                                           */
  15. /*    Thomas R. Lawrence can be reached at tomlaw@world.std.com.             */
  16. /*                                                                           */
  17. /*****************************************************************************/
  18.  
  19. #include "MiscInfo.h"
  20. #include "Audit.h"
  21. #include "Debug.h"
  22. #include "Definitions.h"
  23.  
  24. #pragma options(pack_enums)
  25. #include <Files.h>
  26. #pragma options(!pack_enums)
  27.  
  28.  
  29. #if AUDIT
  30.  
  31. typedef void *va_list;
  32. #define __va(arg)  &arg + 1
  33. #define va_start(p,arg)  p = __va(arg)
  34. #define va_arg(p, type)  *(*(type**)&p)++
  35. #define va_end(p)
  36.  
  37. static short                AuditRefNum;
  38. static MyBoolean        AuditInitialized = False;
  39.  
  40. static char                    Hex[16] = {'0','1','2','3','4','5','6','7',
  41.                                             '8','9','a','b','c','d','e','f'};
  42.  
  43. #pragma options(!mc68020) /* this code works no matter what */
  44.  
  45.  
  46. static void                    INITAUDIT(void)
  47.     {
  48.         unsigned char            FileName[] = {"\p!!Audit Trail"};
  49.  
  50.         FSDelete(FileName,0);
  51.         ERROR(Create(FileName,0,AUDITCREATOR,'TEXT') != noErr,
  52.             PRERR(ForceAbort,"Audit_Init couldn't create audit trail file."));
  53.         ERROR(FSOpen(FileName,0,&AuditRefNum) != noErr,
  54.             PRERR(ForceAbort,"Audit_Init couldn't open audit trail file for writing."));
  55.         AuditInitialized = True;
  56.     }
  57.  
  58.  
  59. void                                ENDAUDIT(void)
  60.     {
  61.         FSClose(AuditRefNum);
  62.     }
  63.  
  64.  
  65. static void                    FlushBuffer(char Buffer[1024], short* BufPtr, MyBoolean FlushAllFlag)
  66.     {
  67.         char*                            Place;
  68.         long                            Count;
  69.  
  70.         if ((*BufPtr >= 512) || (FlushAllFlag))
  71.             {
  72.                 Place = Buffer;
  73.                 while (*BufPtr != 0)
  74.                     {
  75.                         Count = *BufPtr;
  76.                         FSWrite(AuditRefNum,&Count,Place);
  77.                         *BufPtr -= Count;
  78.                         Place += Count;
  79.                     }
  80.             }
  81.     }
  82.  
  83.  
  84. #define COLUMNS (16)
  85. void                                AHEXDUMP(char* Ptr, long NumBytes)
  86.     {
  87.         while (NumBytes > 0)
  88.             {
  89.                 int                                Scan;
  90.                 char                            Buffer[1 + 3*COLUMNS + 1 + COLUMNS + 1];
  91.                 short                            Index;
  92.  
  93.                 Index = 0;
  94.                 Buffer[Index++] = 32;
  95.                 for (Scan = 0; Scan < COLUMNS; Scan += 1)
  96.                     {
  97.                         if (NumBytes > Scan)
  98.                             {
  99.                                 Buffer[Index++] = Hex[(((unsigned char*)Ptr)[Scan] >> 4) & 0x0f];
  100.                                 Buffer[Index++] = Hex[(((unsigned char*)Ptr)[Scan]) & 0x0f];
  101.                                 Buffer[Index++] = 32;
  102.                             }
  103.                          else
  104.                             {
  105.                                 Buffer[Index++] = 32;
  106.                                 Buffer[Index++] = 32;
  107.                                 Buffer[Index++] = 32;
  108.                             }
  109.                     }
  110.                 Buffer[Index++] = 32;
  111.                 for (Scan = 0; Scan < COLUMNS; Scan += 1)
  112.                     {
  113.                         if (NumBytes > Scan)
  114.                             {
  115.                                 if ((((unsigned char*)Ptr)[Scan] >= 32)
  116.                                     && (((unsigned char*)Ptr)[Scan] <= 126))
  117.                                     {
  118.                                         Buffer[Index++] = ((unsigned char*)Ptr)[Scan];
  119.                                     }
  120.                                  else
  121.                                     {
  122.                                         Buffer[Index++] = '.';
  123.                                     }
  124.                             }
  125.                          else
  126.                             {
  127.                                 Buffer[Index++] = 32;
  128.                             }
  129.                     }
  130.                 Buffer[Index++] = 13;
  131.                 FlushBuffer(Buffer,&Index,True/*force write*/);
  132.                 Ptr += COLUMNS;
  133.                 NumBytes -= COLUMNS;
  134.             }
  135.     }
  136.  
  137.  
  138. /* this prints a string in the same way that printf does.  it accepts these options: */
  139. /* %s = decimal signed short */
  140. /* $xs = hexadecimal short */
  141. /* %l = decimal signed long */
  142. /* %xl = hexadecimal long */
  143. /* %b = boolean from short */
  144. /* %c = decimal signed char */
  145. /* %xc = hexadecimal char */
  146. /* %t = C String (text) */
  147. /* %p = Pascal string */
  148. /* %r = Reference (a pointer) */
  149. void                                AuditPrint(char* Str,...)
  150.     {
  151.         va_list                        pa;
  152.         char                            Buffer[1024];
  153.         short                            BufPtr;
  154.         short                            VRefNum;
  155.  
  156.         if (!AuditInitialized)
  157.             {
  158.                 INITAUDIT();
  159.             }
  160.         BufPtr = 0;
  161.         va_start(pa,Str);
  162.         while (*Str != 0)
  163.             {
  164.                 if (*Str == '%')
  165.                     {
  166.                         MyBoolean                HexFlag;
  167.  
  168.                         Str += 1;
  169.                         HexFlag = (*Str == 'x');
  170.                         if (HexFlag)
  171.                             {
  172.                                 Str += 1;
  173.                             }
  174.                         switch (*Str)
  175.                             {
  176.                                 case 'r':
  177.                                     HexFlag = 1;
  178.                                     goto PrintLong; /* sizeof(pointer) == sizeof(long) on 68000 */
  179.                                 case 'l':
  180.                                     {
  181.                                         unsigned long        Num;
  182.  
  183.                                      PrintLong:
  184.                                         Num = va_arg(pa,long);
  185.                                         if (HexFlag)
  186.                                             {
  187.                                                 char                        Buf[9];
  188.                                                 short                        Count;
  189.  
  190.                                                 for (Count = 8; Count >= 1; Count -= 1)
  191.                                                     {
  192.                                                         Buf[Count] = Hex[Num & 0x0000000f];
  193.                                                         Num = Num >> 4;
  194.                                                     }
  195.                                                 Buf[0] = '$';
  196.                                                 for (Count = 0; Count < 9; Count += 1)
  197.                                                     {
  198.                                                         Buffer[BufPtr++] = Buf[Count];
  199.                                                     }
  200.                                             }
  201.                                          else
  202.                                             {
  203.                                                 char                        Buf[16];
  204.                                                 short                        BPtr;
  205.                                                 short                        Scan;
  206.  
  207.                                                 if (Num == -2147483648)
  208.                                                     {
  209.                                                         char        Apl[] = "-2147483648";
  210.                                                         short        Scan;
  211.  
  212.                                                         for (Scan = 0; Apl[Scan] != 0; Scan += 1)
  213.                                                             {
  214.                                                                 Buffer[BufPtr++] = Apl[Scan];
  215.                                                             }
  216.                                                     }
  217.                                                  else
  218.                                                     {
  219.                                                         if (Num < 0)
  220.                                                             {
  221.                                                                 Buffer[BufPtr++] = '-';
  222.                                                                 Num = -Num;
  223.                                                             }
  224.                                                         BPtr = 16;
  225.                                                         do
  226.                                                             {
  227.                                                                 Buf[--BPtr] = (Num % 10) + '0';
  228.                                                                 Num = Num / 10;
  229.                                                             } while (Num != 0);
  230.                                                         for (Scan = BPtr; Scan < 16; Scan += 1)
  231.                                                             {
  232.                                                                 Buffer[BufPtr++] = Buf[Scan];
  233.                                                             }
  234.                                                     }
  235.                                             }
  236.                                     }
  237.                                     Str += 1;
  238.                                     break;
  239.                                 case 's':
  240.                                     {
  241.                                         unsigned short        Num;
  242.  
  243.                                         Num = va_arg(pa,short);
  244.                                         if (HexFlag)
  245.                                             {
  246.                                                 char                        Buf[5];
  247.                                                 short                        Count;
  248.  
  249.                                                 for (Count = 4; Count >= 1; Count -= 1)
  250.                                                     {
  251.                                                         Buf[Count] = Hex[Num & 0x000f];
  252.                                                         Num = Num >> 4;
  253.                                                     }
  254.                                                 Buf[0] = '$';
  255.                                                 for (Count = 0; Count < 5; Count += 1)
  256.                                                     {
  257.                                                         Buffer[BufPtr++] = Buf[Count];
  258.                                                     }
  259.                                             }
  260.                                          else
  261.                                             {
  262.                                                 if (Num == -32768)
  263.                                                     {
  264.                                                         char                        Apl[] = "-32768";
  265.                                                         short                        Scan;
  266.  
  267.                                                         for (Scan = 0; Apl[Scan] != 0; Scan += 1)
  268.                                                             {
  269.                                                                 Buffer[BufPtr++] = Apl[Scan];
  270.                                                             }
  271.                                                     }
  272.                                                  else
  273.                                                     {
  274.                                                         char                        Buf[8];
  275.                                                         short                        BPtr;
  276.                                                         short                        Scan;
  277.  
  278.                                                         if (Num < 0)
  279.                                                             {
  280.                                                                 Buffer[BufPtr++] = '-';
  281.                                                                 Num = -Num;
  282.                                                             }
  283.                                                         BPtr = 8;
  284.                                                         do
  285.                                                             {
  286.                                                                 Buf[--BPtr] = (Num % 10) + '0';
  287.                                                                 Num = Num / 10;
  288.                                                             } while (Num != 0);
  289.                                                         for (Scan = BPtr; Scan < 8; Scan += 1)
  290.                                                             {
  291.                                                                 Buffer[BufPtr++] = Buf[Scan];
  292.                                                             }
  293.                                                     }
  294.                                             }
  295.                                     }
  296.                                     Str += 1;
  297.                                     break;
  298.                                 case 'c':
  299.                                     {
  300.                                         unsigned char        Num;
  301.  
  302.                                         Num = (va_arg(pa,short)) & 0x00ff;
  303.                                         if (HexFlag)
  304.                                             {
  305.                                                 char                        Buf[3];
  306.                                                 short                        Count;
  307.  
  308.                                                 for (Count = 2; Count >= 1; Count -= 1)
  309.                                                     {
  310.                                                         Buf[Count] = Hex[Num & 0x0f];
  311.                                                         Num = Num >> 4;
  312.                                                     }
  313.                                                 Buf[0] = '$';
  314.                                                 for (Count = 0; Count < 3; Count += 1)
  315.                                                     {
  316.                                                         Buffer[BufPtr++] = Buf[Count];
  317.                                                     }
  318.                                             }
  319.                                          else
  320.                                             {
  321.                                                 if (Num == -128)
  322.                                                     {
  323.                                                         char                        Apl[] = "-128";
  324.                                                         short                        Scan;
  325.  
  326.                                                         for (Scan = 0; Apl[Scan] != 0; Scan += 1)
  327.                                                             {
  328.                                                                 Buffer[BufPtr++] = Apl[Scan];
  329.                                                             }
  330.                                                     }
  331.                                                  else
  332.                                                     {
  333.                                                         char                        Buf[4];
  334.                                                         short                        BPtr;
  335.                                                         short                        Scan;
  336.  
  337.                                                         if (Num < 0)
  338.                                                             {
  339.                                                                 Buffer[BufPtr++] = '-';
  340.                                                                 Num = -Num;
  341.                                                             }
  342.                                                         BPtr = 4;
  343.                                                         do
  344.                                                             {
  345.                                                                 Buf[--BPtr] = (Num % 10) + '0';
  346.                                                                 Num = Num / 10;
  347.                                                             } while (Num != 0);
  348.                                                         for (Scan = BPtr; Scan < 4; Scan += 1)
  349.                                                             {
  350.                                                                 Buffer[BufPtr++] = Buf[Scan];
  351.                                                             }
  352.                                                     }
  353.                                             }
  354.                                             Str += 1;
  355.                                             break;
  356.                                         case 't':
  357.                                             {
  358.                                                 char*                        Strp;
  359.  
  360.                                                 Strp = va_arg(pa,char*);
  361.                                                 while (*Strp != 0)
  362.                                                     {
  363.                                                         Buffer[BufPtr++] = *(Strp++);
  364.                                                         FlushBuffer(Buffer,&BufPtr,False);
  365.                                                     }
  366.                                             }
  367.                                             Str += 1;
  368.                                             break;
  369.                                         case 'p':
  370.                                             {
  371.                                                 char*                            Temp;
  372.                                                 short                            Scan;
  373.  
  374.                                                 Temp = va_arg(pa,char*);
  375.                                                 for (Scan = 0; Scan != Temp[0]; Scan += 1)
  376.                                                     {
  377.                                                         Buffer[BufPtr++] = Temp[Scan+1];
  378.                                                     }
  379.                                             }
  380.                                             Str += 1;
  381.                                             break;
  382.                                         case 'b':
  383.                                             {
  384.                                                 MyBoolean                Num;
  385.                                                 char*                        Strptr;
  386.                                                 short                        Cnt;
  387.  
  388.                                                 Num = va_arg(pa,MyBoolean);
  389.                                                 if (Num)
  390.                                                     {
  391.                                                         Strptr = "True";
  392.                                                     }
  393.                                                  else
  394.                                                     {
  395.                                                         Strptr = "False";
  396.                                                     }
  397.                                                 for (Cnt = 0; Strptr[Cnt] != 0; Cnt += 1)
  398.                                                     {
  399.                                                         Buffer[BufPtr++] = Strptr[Cnt];
  400.                                                     }
  401.                                             }
  402.                                             Str += 1;
  403.                                             break;
  404.                                         default:
  405.                                             {
  406.                                                 short                        Cnt;
  407.                                                 char                        Msg[] = "???";
  408.  
  409.                                                 for (Cnt = 0; Msg[Cnt] != 0; Cnt += 1)
  410.                                                     {
  411.                                                         Buffer[BufPtr++] = Msg[Cnt];
  412.                                                     }
  413.                                             }
  414.                                             Str += 1;
  415.                                             break;
  416.                                     }
  417.                             }
  418.                     }
  419.                  else
  420.                     {
  421.                         Buffer[BufPtr++] = *(Str++);
  422.                     }
  423.                 FlushBuffer(Buffer,&BufPtr,False);
  424.             }
  425.         Buffer[BufPtr++] = 0x0d;
  426.         FlushBuffer(Buffer,&BufPtr,True);
  427. #if AUDITFLUSHING
  428.         GetVRefNum(AuditRefNum,&VRefNum);
  429.         FlushVol("\p",VRefNum);
  430. #endif
  431.     }
  432.  
  433. #endif
  434.